//并发请求
function concurrentRequests(urls, maxConcurrent) {
    // 存储Promise数组，用于等待所有请求完成
    const allPromises = [];
    // 用于追踪当前活跃的（即尚未完成的）请求数
    let activeRequests = 0;
    // 存储所有完成的响应数据
    const results = [];

    // 定义执行单个请求的函数
    function fetchOne(url) {
        // 确保没有超出最大并发数
        if (activeRequests >= maxConcurrent) {
            // 这里实际上不会真正"等待"，因为JavaScript是单线程的，但我们可以在Promise链中处理它
            return new Promise((resolve, reject) => {
                setTimeout(() => {
                    fetchOne(url).then(resolve).catch(reject); // 递归重试
                }, 0); // 立即检查（但不会阻塞事件循环）
            });
        }

        // 增加一个活动请求
        activeRequests++;

        // 发起fetch请求
        return fetch(url)
            .then(response => {
                if (!response.ok) {
                    throw new Error(`HTTP error! status: ${response.status}`);
                }
                return response.json(); // 假设响应是JSON格式
            })
            .then(data => {
                // 处理完成，从结果数组中添加数据，并减少活动请求数
                results.push(data);
                activeRequests--;
                return data;
            })
            .catch(error => {
                // 发生错误，也减少活动请求数
                activeRequests--;
                throw error; // 重新抛出错误，以便在上层catch中捕获
            });
    }

    // 对每个URL执行fetchOne，并收集所有的Promises
    urls.forEach(url => {
        allPromises.push(fetchOne(url));
    });

    // 使用Promise.all等待所有请求完成
    return Promise.all(allPromises).then(() => {
        return results; // 返回所有请求的结果数组
    });
}

// 使用示例
const urls = [
    'https://api.example.com/data1',
    'https://api.example.com/data2',
    // 更多URL...
];

concurrentRequests(urls, 5).then(results => {
    console.log(results); // 输出所有请求的结果
}).catch(error => {
    console.error(error); // 处理可能出现的错误
});




function callInterfaceA() {
    return new Promise((resolve, reject) => {
        // 模拟接口 A 的异步操作
        setTimeout(() => {
            console.log("接口 A 返回结果");
            resolve("接口 A 的结果");
        }, 3000); // 假设接口 A 需要 3 秒钟来返回结果
    });
}

function callInterfaceB() {
    return new Promise((resolve, reject) => {
        // 模拟接口 B 的异步操作
        setTimeout(() => {
            console.log("接口 B 返回结果");
            resolve("接口 B 的结果");
        }, 2000); // 假设接口 B 需要 2 秒钟来返回结果
    });
}

async function executeSequence() {
    let timeoutId;
    try {
        const timeoutPromise = new Promise((resolve, reject) => {
            timeoutId = setTimeout(() => {
                console.log("接口 A 超时");
                resolve("超时");
            }, 5000); // 设置 5 秒的超时
        });

        // 使用 race 方法来决定哪个先完成
        const result = await Promise.race([callInterfaceA(), timeoutPromise]);

        // 清除超时计时器
        clearTimeout(timeoutId);

        if (result === "超时") {
            console.log("由于超时，直接执行接口 B");
        } else {
            console.log("接口 A 成功返回结果，继续执行接口 B");
        }

        // 不管是因为超时还是接口 A 返回，都继续调用接口 B
        await callInterfaceB();
    } catch (error) {
        console.error("发生错误:", error);
    }
}

executeSequence();

